En los años de la pandemia, en los Estados Unidos de América, el comportamiento del uso de tarjetas de crédito ha variado bastante. El promedio de la deuda de tarjeta de crédito creció en 52% entre el 2018 y el 2019, sin embargo, este porcentaje ha caÃdo significativamente en el 2020 (ValuePenguin)(Household Debt and Credit Report, NewYorkFed).
Estados Unidos tiene una deuda de 807 mil millones de dolares distribuidas en 506 millones de tarjetas de crédito mientras que la deuda promedio de una familia Estadounidense es de 6,270 dolares. Estos números incrementan cada año hasta el 2020 donde se vio un decremento debido al COVID-19. En el 2020 la deuda promedio por familia disminuyó a 5,315 dolares, casi 1,000 dolares. La pandemia tuvo un gran impacto en la vida de todos lo cual causó cambios que atribuyen estos cambios de deudas. Entre estos cambios está el hecho que la gente utilizaba menos su dinero en compras y gastos al igual que muchos recibieron dinero suplementario por desempleo o por otras razones que pueden utilizar para estas deudas (Resendiz, 2021).
Además, para poder conocer más sobre las posibles causas del decremento de deudas se investigó sobre diferentes métodos para resolver dichas situaciones económicas. La primera es a través de las compañÃas de liquidación de deudas. Estas compañÃas ofrecen negociar con los emisores de tarjetas de crédito para que el endeudado tenga la opción de disminuir la cantidad que debe pero debe tomar en cuenta que esa negociación puede tomar tiempo y debe pagarle a dicha compañÃa de liquidación. Además, debe tener cuidado con compañÃas fraudulentas que simplemente lo pondrán en una peor situación (Comision Federal de Comercio).
Otra opción serÃa que el individuo con impago negocie directamente con los acreedores. Es posible que le den una tasa de interés más baja la cual facilita el pago de deuda. Una tasa más baja indica que una menor cantidad de cada pago mensual que realice se consuma a causa de los cargos por intereses acumulados y por ende se podrá pagar la deuda de manera más rápida. Cabe mencionar que maximizar su flujo de efectivo es crucial. Ya sea al conseguir nuevos/mejores empleos o minimizar sus gastos cada cantidad ayuda. Además, debe organizar y priorizar sus deudas. Al analizar y ordenar todas las deudas que tiene lo ayudará desarrollar un plan que indique cómo y en qué orden irá pagando (Debt).
Se puede observar que estos datos y soluciones dependen mucho de los individuos que tienen la deuda. Por lo mismo es importante saber que caracterÃsticas tiene un cliente que cae en incumplimiento de pago de tarjeta de crédito. El objetivo de este proyecto es crear modelos de aprendizaje automático que permita predecir qué tipo de clientes podrán caer en impago, o no. Para esto se cuenta con un conjunto de datos que contiene información sobre pagos predeterminados, factores demográficos, datos crediticios, historial de pagos y extractos de cuentas de clientes de tarjetas de crédito en Taiwán desde abril de 2005 hasta septiembre de 2005.
Generales:
Especificos:
Descripcion del dataset como estaba:
Hay 25 variables (22 cuantitativas, 3 categoricas):
import pandas as pd
import numpy as np
from pandas_profiling import ProfileReport
import seaborn as sn
import matplotlib.pyplot as plt
from quickda.clean_data import *
from quickda.explore_data import *
from quickda.clean_data import *
from collections import Counter
df = pd.read_csv("UCI_Credit_Card.csv")
df.head()
explore(df, method="summarize")
profile = ProfileReport(df, minimal=True)
profile
df = clean(df, method = "standardize")
df.head()
to_categoric = ["sex", "education", "marriage",
"pay_0", "pay_2","pay_3", "pay_4", "pay_5","pay_6","default.payment.next.month"]
df = clean(df, method = 'dtypes', columns = to_categoric,
dtype='category')
df = df.rename(columns = {'pay_0': 'pay_1',}, inplace = False)
explore(df, method="summarize")
df = clean(df, method = 'dropcols', columns = ['id'])
df = clean(df, method = "replaceval",
columns = ["education"],
to_replace = [0,5,6],
value = 5)
df = clean(df, method = "replaceval",
columns = ["marriage"],
to_replace = [0],
value = 3)
correlation = df.corr()
plt.figure(figsize = (13, 10))
sn.heatmap(correlation, annot=True)
plt.show()
Se observa que entre las variables Bill_Amt existe mucha correalacion entre ellas, se planico unificar estos datos en uno que represente el promedio entre ellos.
dfSimp = df
promedio = (dfSimp["bill_amt1"]+dfSimp["bill_amt2"]+dfSimp["bill_amt3"]
+dfSimp["bill_amt4"]+dfSimp["bill_amt5"]+dfSimp["bill_amt6"])/6
dfSimp["prom_bill_amt"] = promedio
dfSimp = clean(dfSimp, method = 'dropcols', columns = ['bill_amt1',"bill_amt2","bill_amt3","bill_amt4","bill_amt5","bill_amt6"])
cols = ['limit_bal', 'sex','education','marriage','age','pay_1','pay_2','pay_3',
'pay_4','pay_5','pay_6','prom_bill_amt','pay_amt1','pay_amt2','pay_amt3','pay_amt4','pay_amt5',
'pay_amt6','default.payment.next.month']
dfSimp = dfSimp[cols]
correlation = dfSimp.corr()
plt.figure(figsize = (13, 10))
sn.heatmap(correlation, annot=True)
plt.show()
explore(dfSimp, method="summarize")
#Creacion de graficas para visualizar cada columna del dataset
dfSimp.hist(figsize=(30, 25))
dfSimp['education'].value_counts().plot(kind='bar', title = "Educacion")
Se observa que el nivel de educacion con mas incidencias es el universitario, segido por estudios de postgrado.
dfSimp['marriage'].value_counts().plot(kind='bar', title = "Estado civil")
Al analizar el estado civil podemos ver que el predominante es soltero/a sin embargo tambien hay una buena cantidad de casados, mientras la categorias otros es muy baja.
dfSimp['sex'].value_counts().plot(kind='bar', title = "Sexo")
Se ve que hay una mayor incidencia del sexo femenino que el masculino.
dfSimp['default.payment.next.month'].value_counts().plot(kind='bar', title = "Impago")
El dataset esta imbalanceado en relacion a la varible respuesta, hay muchas mas incidencias de aquellos que impagan que aquellos que no.
pd.crosstab(dfSimp.education, dfSimp['default.payment.next.month']).plot(kind="bar",figsize=(15,6), title = "Analisis de pago por educacion")
plt.xlabel('Educacion')
plt.xticks(rotation=0)
plt.legend(["Impago", "Pago"])
plt.show()
Se observa que los el nivel educativo universitario tiene una alta taza de impago, sin embargo, al analizarlo con posgrado podemos ver que se mantienen en el mismo rango.
pd.crosstab(dfSimp.age, dfSimp['default.payment.next.month']).plot(kind="bar",figsize=(15,6), title = "Analisis de pago por edad")
plt.xlabel('Edad')
plt.xticks(rotation=0)
plt.legend(["Impago", "Pago"])
plt.show()
Se observa que el rando de edad de 23 a 40 suelen caer en impago, vemos que la mayor cantidad de incidencias de impago esta en la dedad de los 29.
pd.crosstab(dfSimp.sex, dfSimp['default.payment.next.month']).plot(kind="bar",figsize=(15,6), title = "Analisis de pago por sexo")
plt.xlabel('Genero')
plt.xticks(rotation=0)
plt.legend(["Impago", "Pago"])
plt.show()
Aqui hay que tener en cuenta que existen muchas mas datos del genero femenino, sin embargo, el genero masculino tiene casi una alta tasa de pago a pesar de ser menos cantidad.
pd.crosstab(dfSimp.marriage, dfSimp['default.payment.next.month']).plot(kind="bar",figsize=(15,6),title = "Analisis de pago por estado civil")
plt.xlabel('Estado Civil')
plt.xticks(rotation=0)
plt.legend(["Impago", "Pago"])
plt.show()
Vemos que ambos estados civiles tienen casi la misma cantidad de personas que pagaron apesar de que el estado civil soltero tiene mas incidencias.
sns.catplot(x="default.payment.next.month", y="limit_bal", data=dfSimp)
Comparacion pago/impago segun el valor del credito otorgado
sns.catplot(x="education", y="limit_bal", data=dfSimp)
Comparacion educacion segun credito otorgado
sns.catplot(x="default.payment.next.month", y="prom_bill_amt", data=dfSimp)
Comparacion pago/impago segun el promedio de monto facturado en los diferentes meses.
En caso de pasar por alto alguna grafica importante con la siguiente herramienta se puede realizar varios tipos de graficos.
from autoplotter import run_app
run_app(dfSimp, mode = "external", host="127.0.0.1", port=5000)
El conjunto de datos tras las operaciones de limpieza cuenta con 30000 observaciones y 19 variables. De estas variables:
Al analizar las variables cualitativas podemos notar ciertas caracterÃsticas importantes como:
De las variables cuantitativos podemos observar lo siguiente:
Al cruzar variables podemos observar lo siguiente:
El primer paso para prepar los datos con el fin de crear modelos es la creacion de variables dummy para las varibales categoricas, estas se agregan al dataset y se eliminan las otras columnas.
dfSimp = pd.concat([dfSimp.drop(columns=['sex'], axis=1), pd.get_dummies(dfSimp['sex'], drop_first=True)], axis=1)
dfSimp = pd.concat([dfSimp.drop(columns=['marriage'], axis=1), pd.get_dummies(dfSimp['marriage'], drop_first=True)], axis=1)
dfSimp = pd.concat([dfSimp.drop(columns=['education'], axis=1), pd.get_dummies(dfSimp['education'], drop_first=True)], axis=1)
dfSimp = pd.concat([dfSimp.drop(columns=['pay_1'], axis=1), pd.get_dummies(dfSimp['pay_1'], drop_first=True)], axis=1)
dfSimp = pd.concat([dfSimp.drop(columns=['pay_2'], axis=1), pd.get_dummies(dfSimp['pay_2'], drop_first=True)], axis=1)
dfSimp = pd.concat([dfSimp.drop(columns=['pay_3'], axis=1), pd.get_dummies(dfSimp['pay_3'], drop_first=True)], axis=1)
dfSimp = pd.concat([dfSimp.drop(columns=['pay_4'], axis=1), pd.get_dummies(dfSimp['pay_4'], drop_first=True)], axis=1)
dfSimp = pd.concat([dfSimp.drop(columns=['pay_5'], axis=1), pd.get_dummies(dfSimp['pay_5'], drop_first=True)], axis=1)
dfSimp = pd.concat([dfSimp.drop(columns=['pay_6'], axis=1), pd.get_dummies(dfSimp['pay_6'], drop_first=True)], axis=1)
dfSimp
Se separan los datos en train y test con una distribucion de 80% y 20% respectivamente
from sklearn.model_selection import train_test_split
X = dfSimp.drop(columns='default.payment.next.month')
Y = dfSimp['default.payment.next.month']
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=101)
print("Antes del oversampling: ",Counter(y_train))
from imblearn.over_sampling import SMOTE
sm = SMOTE(sampling_strategy = 1)
x = np.array(X_train)
y = y_train.ravel()
X_train_SMOTE, y_train_SMOTE = sm.fit_resample(x, y)
print("Luego del oversampling: ",Counter(y_train_SMOTE))
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train_SMOTE)
X_test = scaler.transform(X_test)
Luego de analizar y preparar la data, estamos listos para crear modelos de clasificacion. Elegimos 5 modelos: SVM, Regresion Logistica, Random Forest, Nave Bayes y XGBoost. Decidimos trabajar con los primeros 4 modelos ya que los hemos utilizado en otros proyectos, son populares y son adecuados para el tipo de dataset que tenemos y para resolver problemas como el que presentamos. Tambien implementaremos XGBoost ya que es uno de los modelos mas relevantes actualmente e igualmente es adecuado para este proyecto. Primero realizamos las importaciones necesarias para obtener las metricas que evaluaran a los modelos
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
from sklearn.metrics import roc_auc_score
from sklearn.metrics import mean_squared_error
from sklearn.metrics import roc_curve
from sklearn.metrics import plot_roc_curve
from sklearn.metrics import precision_recall_curve
from sklearn import metrics
from matplotlib import pyplot
accuracy = []
recall = []
f1 = []
roc = []
A continuacion crearemos los modelos previamente mencionados y haremos predicciones con los datos X_test. En base a esas predicciones obtenemos las metricas de precision, recall, f1-score, support y accuracy. Ademas, para cada modelo realizamos un reporte de clasificacion junto a graficas de su matriz de confusion, su curva de roc-auc y su curva de precision-recall.
from sklearn import svm
svmc = svm.SVC(random_state=51, probability=True)
svmc.fit(X_train, y_train_SMOTE)
y_pred = svmc.predict(X_test)
print(classification_report(y_test, y_pred))
accuracy.append(accuracy_score(y_test, y_pred))
recall.append(recall_score(y_test, y_pred))
f1.append(f1_score(y_test, y_pred))
roc.append(roc_auc_score(y_test, y_pred))
fpr_SVM, tpr_SVM, treshold_SVM = roc_curve(y_test, y_pred)
cnf_matrix = confusion_matrix(y_test, y_pred)
class_names=[0,1]
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
# create heatmap
sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
ax.xaxis.set_label_position("top")
plt.tight_layout()
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Predicted label')
svm_disp = plot_roc_curve(svmc, X_test, y_test)
plt.plot([0, 1], [0, 1], color="red", lw=2, linestyle="--")
plt.show()
m_probs = svmc.predict_proba(X_test)
m_precision, m_recall, _ = precision_recall_curve(y_test, m_probs[:, 1])
no_skill = len(y_test[y_test==1]) / len(y_test)
pyplot.plot([0, 1], [no_skill, no_skill], linestyle='--', label='No Skill')
pyplot.plot(m_recall, m_precision, marker='.', label='Logistic')
# axis labels
pyplot.xlabel('Recall')
pyplot.ylabel('Precision')
# show the legend
pyplot.legend()
# show the plot
pyplot.show()
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(random_state=51)
lr.fit(X_train, y_train_SMOTE)
y_pred = lr.predict(X_test)
print(classification_report(y_test, y_pred))
accuracy.append(accuracy_score(y_test, y_pred))
recall.append(recall_score(y_test, y_pred))
f1.append(f1_score(y_test, y_pred))
roc.append(roc_auc_score(y_test, y_pred))
fpr_RL, tpr_RL, treshold_RL = roc_curve(y_test, y_pred)
cnf_matrix = confusion_matrix(y_test, y_pred)
class_names=[0,1]
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
# create heatmap
sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
ax.xaxis.set_label_position("top")
plt.tight_layout()
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Predicted label')
y_pred_proba = lr.predict_proba(X_test)[::,1]
fpr, tpr, _ = roc_curve(y_test, y_pred_proba)
auc = roc_auc_score(y_test, y_pred_proba)
plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
plt.legend(loc=4)
plt.show()
m_probs = lr.predict_proba(X_test)
m_precision, m_recall, _ = precision_recall_curve(y_test, m_probs[:, 1])
no_skill = len(y_test[y_test==1]) / len(y_test)
pyplot.plot([0, 1], [no_skill, no_skill], linestyle='--', label='No Skill')
pyplot.plot(m_recall, m_precision, marker='.', label='Logistic')
# axis labels
pyplot.xlabel('Recall')
pyplot.ylabel('Precision')
# show the legend
pyplot.legend()
# show the plot
pyplot.show()
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(random_state=51)
rf.fit(X_train, y_train_SMOTE)
y_pred = rf.predict(X_test)
print(classification_report(y_test, y_pred))
accuracy.append(accuracy_score(y_test, y_pred))
recall.append(recall_score(y_test, y_pred))
f1.append(f1_score(y_test, y_pred))
roc.append(roc_auc_score(y_test, y_pred))
fpr_RF, tpr_RF, treshold_RF = roc_curve(y_test, y_pred)
cnf_matrix = confusion_matrix(y_test, y_pred)
class_names=[0,1]
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
# create heatmap
sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
ax.xaxis.set_label_position("top")
plt.tight_layout()
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Predicted label')
rf_disp = plot_roc_curve(rf, X_test, y_test)
plt.plot([0, 1], [0, 1], color="red", lw=2, linestyle="--")
plt.show()
m_probs = rf.predict_proba(X_test)
m_precision, m_recall, _ = precision_recall_curve(y_test, m_probs[:, 1])
no_skill = len(y_test[y_test==1]) / len(y_test)
pyplot.plot([0, 1], [no_skill, no_skill], linestyle='--', label='No Skill')
pyplot.plot(m_recall, m_precision, marker='.', label='Logistic')
# axis labels
pyplot.xlabel('Recall')
pyplot.ylabel('Precision')
# show the legend
pyplot.legend()
# show the plot
pyplot.show()
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
gnb.fit(X_train, y_train_SMOTE)
y_pred = gnb.predict(X_test)
print(classification_report(y_test, y_pred))
accuracy.append(accuracy_score(y_test, y_pred))
recall.append(recall_score(y_test, y_pred))
f1.append(f1_score(y_test, y_pred))
roc.append(roc_auc_score(y_test, y_pred))
fpr_NB, tpr_NB, treshold_NB = roc_curve(y_test, y_pred)
cnf_matrix = confusion_matrix(y_test, y_pred)
class_names=[0,1]
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
# create heatmap
sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
ax.xaxis.set_label_position("top")
plt.tight_layout()
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Predicted label')
gnb_disp = plot_roc_curve(gnb, X_test, y_test)
plt.plot([0, 1], [0, 1], color="red", lw=2, linestyle="--")
plt.show()
m_probs = gnb.predict_proba(X_test)
m_precision, m_recall, _ = precision_recall_curve(y_test, m_probs[:, 1])
no_skill = len(y_test[y_test==1]) / len(y_test)
pyplot.plot([0, 1], [no_skill, no_skill], linestyle='--', label='No Skill')
pyplot.plot(m_recall, m_precision, marker='.', label='Logistic')
# axis labels
pyplot.xlabel('Recall')
pyplot.ylabel('Precision')
# show the legend
pyplot.legend()
# show the plot
pyplot.show()
Para este modelo buscaremos parametros optimizados para obtener mejores resultados. Los parametros que estaremos optimizando incluyen max_depth, learning_rate, gamma, subsample y colsample_bytree.
NOTA: Esta optimizacion tarda bastante tiempo en ejecutar por lo que se ha comentado el codigo que busca los parametros y se colocaron los valores encontrados en la creacion del modelo
import xgboost as xgb
Creamos un diccionario con los parametros que queremos optimizar y el rango de valores que se probaran para cada uno
""""
param_grid = {
"max_depth": [3, 4, 5, 7],
"learning_rate": [0.1, 0.01, 0.05],
"gamma": [0, 0.25, 1],
"subsample": [0.5, 0.6, 0.7, 0.8, 0.9, 0.1],
"colsample_bytree": [0.5, 0.6, 0.7, 0.8, 0.9, 0.1],
}
""""
Importamos GridSearchCV el cual utilizaremos para buscar los mejores valores para los parametros en base de su roc-auc
"""
from sklearn.model_selection import GridSearchCV
xgb_cl = xgb.XGBClassifier(objective="binary:logistic")
grid_cv = GridSearchCV(xgb_cl, param_grid, n_jobs=-1, cv=3, scoring="roc_auc")
_ = grid_cv.fit(X_train, y_train_SMOTE)
"""
#grid_cv.best_score_
#grid_cv.best_params_
Se encontraron valores optimizados para los parametros. Sin embargo, max_depth y gamma tienen el valor mas alto del rango que se dio por lo que debemos probar mas valores.
"""
#Valores fijos
param_grid["learning_rate"] = [0.05]
param_grid["subsample"] = [0.9]
param_grid["colsample_bytree"] = [0.6]
#Nuevos valores
param_grid["gamma"] = [3, 5, 7]
param_grid["max_depth"] = [9, 15, 20]
"""
#grid_cv_2 = GridSearchCV(xgb_cl, param_grid, cv=3, scoring="roc_auc", n_jobs=-1)
#_ = grid_cv_2.fit(X_train, y_train_SMOTE)
#grid_cv_2.best_score_
#grid_cv_2.best_params_
Luego de la segunda busqueda encontramos los valores que nos daran mejor rendimiento y ahora los colocamos en el modelo
xgbf = xgb.XGBClassifier(
colsample_bytree= 0.6,
gamma= 7,
learning_rate= 0.05,
max_depth= 9,
subsample= 0.9,
objective="binary:logistic"
)
xgbf.fit(X_train, y_train_SMOTE)
y_pred = xgbf.predict(X_test)
print(classification_report(y_test, y_pred))
accuracy.append(accuracy_score(y_test, y_pred))
recall.append(recall_score(y_test, y_pred))
f1.append(f1_score(y_test, y_pred))
roc.append(roc_auc_score(y_test, y_pred))
fpr_XG, tpr_XG, treshold_XG = roc_curve(y_test, y_pred)
cnf_matrix = confusion_matrix(y_test, y_pred)
class_names=[0,1]
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
# create heatmap
sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
ax.xaxis.set_label_position("top")
plt.tight_layout()
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Predicted label')
xgbf_disp = plot_roc_curve(svmc, X_test, y_test)
plt.plot([0, 1], [0, 1], color="red", lw=2, linestyle="--")
plt.show()
m_probs = svmc.predict_proba(X_test)
m_precision, m_recall, _ = precision_recall_curve(y_test, m_probs[:, 1])
no_skill = len(y_test[y_test==1]) / len(y_test)
pyplot.plot([0, 1], [no_skill, no_skill], linestyle='--', label='No Skill')
pyplot.plot(m_recall, m_precision, marker='.', label='Logistic')
# axis labels
pyplot.xlabel('Recall')
pyplot.ylabel('Precision')
# show the legend
pyplot.legend()
# show the plot
pyplot.show()
A continuacion se muestran graficas con diferentes metricas de evaluacion que se obtuvieron para cada modelo para poder compararlos visualmente
modelos = ["SVM", "Reg. Logistica", "Random Forest", "Naive Bayes", "XGBoost"]
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.set_title("Comparacion accuracy")
ax.set_ylabel('Accuracy %')
bars = plt.bar(modelos, height=accuracy)
for bar in bars:
yval = round(bar.get_height(), 2)
print(yval)
plt.text(bar.get_x() + 0.3, yval + .01, yval)
plt.show()
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.set_title("Comparacion recall")
ax.set_ylabel('Recall %')
bars = plt.bar(modelos, height=recall)
for bar in bars:
yval = round(bar.get_height(), 2)
print(yval)
plt.text(bar.get_x() + 0.3, yval + .005, yval)
plt.show()
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.set_title("Comparacion f1")
ax.set_ylabel('f1 %')
bars = plt.bar(modelos, height=f1)
for bar in bars:
yval = round(bar.get_height(), 2)
print(yval)
plt.text(bar.get_x() + 0.3, yval + .005, yval)
plt.show()
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.set_title("Comparacion roc_auc")
ax.set_ylabel('roc_auc %')
bars = plt.bar(modelos, height=roc)
for bar in bars:
yval = round(bar.get_height(), 2)
print(yval)
plt.text(bar.get_x() + 0.3, yval + .01, yval)
plt.show()
Visualizacion dinamica de datos en este caso de la curva Roc y AUC
import plotly.express as px
from jupyter_dash import JupyterDash
import dash_core_components as dcc
import dash_html_components as html
from dash.dependencies import Input, Output
auc1 = metrics.auc(fpr_SVM, tpr_SVM)
auc2 = metrics.auc(fpr_RL, tpr_RL)
auc3 = metrics.auc(fpr_RF, tpr_RF)
auc4 = metrics.auc(fpr_NB, tpr_NB)
auc5 = metrics.auc(fpr_XG, tpr_XG)
fig = px.area(
x=fpr_SVM, y=tpr_SVM,
title='SVM ROC Curve AUC='+str(auc1),
labels=dict(x='False Positive Rate', y='True Positive Rate'),
width=500, height=500
)
modelos = ["SVM", "Regresion Logistica", "Random Forest", "Naive Bayes", "XGBoost"]
# Build App
app = JupyterDash(__name__)
app.layout = html.Div([
html.H1("ROC Graphs"),
dcc.Graph(id='graph'),
html.Label([
"Modelo a ver:",
dcc.Dropdown(
id='model-dropdown', clearable=False,
value='SVM', options=[
{'label': c, 'value': c}
for c in modelos
])
]),
])
# Define callback to update graph
@app.callback(
Output('graph', 'figure'),
[Input("model-dropdown", "value")]
)
def update_figure(model):
if model == "SVM":
fpr = fpr_SVM
tpr = tpr_SVM
auc = auc1
elif model == "Regresion Logistica":
fpr = fpr_RL
tpr = tpr_RL
auc = auc2
elif model == "Random Forest":
fpr = fpr_RF
tpr = tpr_RF
auc = auc3
elif model == "Naive Bayes":
fpr = fpr_NB
tpr = tpr_NB
auc = auc4
elif model == "XGBoost":
fpr = fpr_XG
tpr = tpr_XG
auc = auc5
fig = px.area(
x=fpr, y=tpr,
title= model +' ROC Curve AUC='+str(auc),
labels=dict(x='False Positive Rate', y='True Positive Rate'),
width=500, height=500)
fig.add_shape(type='line', line=dict(dash='dash'),x0=0, x1=1, y0=0, y1=1)
return fig
# Run app and display result inline in the notebook
app.run_server(mode='inline',port=9000)
ac_dataframe = pd.DataFrame(list(zip(modelos, accuracy)),
columns =['Modelo', 'Accurracy'])
rec_dataframe = pd.DataFrame(list(zip(modelos, recall)),
columns =['Modelo', 'Recall'])
f1_dataframe = pd.DataFrame(list(zip(modelos, f1)),
columns =['Modelo', 'F1'])
roc_dataframe = pd.DataFrame(list(zip(modelos, roc)),
columns =['Modelo', 'Roc_Auc'])
app = JupyterDash(__name__)
fig1 = px.bar(ac_dataframe, x="Modelo", y="Accurracy", color="Accurracy", barmode="group")
fig2 = px.bar(rec_dataframe, x="Modelo", y="Recall", color="Recall", barmode="group")
fig3 = px.bar(f1_dataframe, x="Modelo", y="F1", color="F1", barmode="group")
fig4 = px.bar(roc_dataframe, x="Modelo", y="Roc_Auc", color="Roc_Auc", barmode="group")
app.layout = html.Div(children=[
# All elements from the top of the page
html.Div([
html.H1(children='Accuracy Comparition'),
dcc.Graph(
id='graph1',
figure=fig1
),
]),
# New Div for all elements in the new 'row' of the page
html.Div([
html.H1(children='Recall Comparition'),
dcc.Graph(
id='graph2',
figure=fig2
),
]),
html.Div([
html.H1(children='F1 Comparition'),
dcc.Graph(
id='graph3',
figure=fig3
),
]),
html.Div([
html.H1(children='Roc Comparition'),
dcc.Graph(
id='graph4',
figure=fig4
),
]),
])
app.run_server(mode='inline',port=7001)